module klang.ir.语法节点.IR节点_;
import 全局;
import std.conv: ·to = to;
import 节点 = klang.编译.语法节点.节点_;
import klang.编译.核心.核心_: 词典_, 去重数组_, 整数_;
import klang.编译.语法节点.节点_: 访问节点, 访问节点组, 节点数组_, 文本字面量_;
import klang.编译.类型.枚举值.枚举值_: SK, TK, 字符_;
import klang.编译.类型.类型_: 符号表_;
import klang.ir.类型.IR类型_: ISK, 标识符分类_, ValIdKind_;
alias 节点_ = IR节点_;
alias 语句_ = IR节点_;
alias 声明_ = IR节点_;
alias 声明语句_ = IR节点_;
alias 类型节点_ = IR节点_;
alias 表达式_ = IR节点_;
alias 摘要节点_ = IR节点_;
alias 标识符_ = IR标识符_;
alias 修饰符_ = IR令牌_!(ISK);
alias 命名声明语句_ = 命名声明_;
alias 命名表达式_ = 命名声明_;
alias MDNode_ = IR节点_;
class IR节点_ : 节点.前端节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(TK.Ir, isk, 开始, 结束);
    }
}
class 命名声明_ : IR节点_ {
    IR标识符_ name;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.name = ··null!(IR标识符_);
    }
}
class IR令牌_(T) : IR节点_ {
    this() { }
    this(T isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class IR源文件_ : 节点.源文件_ {
    dstring SourceFileName;
    dstring GlobalScopeAsm;
    符号表_ 类型组;
    符号表_ 特性组;
    符号表_ 封装组;
    符号表_ 元数据;
    符号表_ 摘要组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(TK.Ir, isk, 开始, 结束);
        this.SourceFileName = ··null!(dstring);
        this.GlobalScopeAsm = ··null!(dstring);
        this.类型组 = ··null!(符号表_);
        this.特性组 = ··null!(符号表_);
        this.封装组 = ··null!(符号表_);
        this.元数据 = ··null!(符号表_);
        this.摘要组 = ··null!(符号表_);
    }
}
class IR标识符_ : IR节点_ {
    dstring 内容;
    标识符分类_ 分类;
    ulong 值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.内容 = ··null!(dstring);
        this.分类 = 标识符分类_.标识符_;
        this.值 = -1;
    }
    this(节点.标识符_ id) {
        super(ISK.标识符, id.开始, id.结束);
        this.内容 = id.内容;
        this.分类 = 标识符分类_.标识符_;
        this.值 = -1;
    }
}
class 字面量类表达式基类_ : IR节点_ {
    dstring 内容;
    dstring 原始文本;
    IR节点_ 文本原节点;
    bool hasExtendedUnicodeEscape = false;
    bool isUnterminated = false;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.内容 = ··null!(dstring);
        this.原始文本 = ··null!(dstring);
        this.文本原节点 = ··null!(IR节点_);
    }
}
class IR数字字面量_ : 字面量类表达式基类_ {
    ulong 整数值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.整数值 = 0;
    }
}
class IR文本字面量_ : 字面量类表达式基类_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class IRc文本字面量_ : IR节点_ {
    string 内容;
    dstring 原始内容;
    bool hasExtendedUnicodeEscape = false;
    bool isUnterminated = false;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.内容 = ··null!(string);
        this.原始内容 = ··null!(dstring);
    }
}
class 全局表达式_ : IR节点_ {
    IR节点_ 类型;
    IR节点_ 表达式;
    IR节点_ InRangeOp;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.表达式 = ··null!(IR节点_);
        this.InRangeOp = ··null!(IR节点_);
    }
}
class 结构常量表达式_ : IR节点_ {
    节点.节点数组_!(IR节点_) 元素组;
    bool 是压缩的;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(IR节点_));
        this.是压缩的 = ··null!(bool);
    }
}
class 向量常量表达式_ : IR节点_ {
    节点.节点数组_!(IR节点_) 元素组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 数组常量表达式_ : IR节点_ {
    节点.节点数组_!(IR节点_) 元素组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
// 
class c文本常量_ : IR节点_ {
    IRc文本字面量_ 内容;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.内容 = ··null!(IRc文本字面量_);
    }
}
class 内联汇编常量表达式_ : IR节点_ {
    IR文本字面量_ StrVal;
    IR文本字面量_ StrVal2;
    IR节点_ HasSideEffect;
    IR节点_ AlignStack;
    IR节点_ AsmDialect;
    IR节点_ CanThrow;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.StrVal = ··null!(IR文本字面量_);
        this.StrVal2 = ··null!(IR文本字面量_);
        this.HasSideEffect = ··null!(IR节点_);
        this.AlignStack = ··null!(IR节点_);
        this.AsmDialect = ··null!(IR节点_);
        this.CanThrow = ··null!(IR节点_);
    }
}
class 设置型节点_ : IR节点_ {
    IR节点_ 值;
    节点.节点数组_!(IR节点_) 值组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(IR节点_);
        this.值组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 全局设置型节点_ : 设置型节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 多用途设置节点_ : 设置型节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 地址空间设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 不可引用的或空设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 不可引用的设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 对齐设置_ : 多用途设置节点_ {
    //值?: IR数字字面量_;
    bool 有括号;
    bool 等号;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.有括号 = false;
        this.等号 = false;
    }
}
class 对齐堆栈设置_ : 多用途设置节点_ {
    // 值?: IR数字字面量_;
    bool 等号;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.等号 = false;
    }
}
class 倍数范围设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 预分配设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 按引用设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 在内部分配设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 结构引用设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 按值设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 分配大小设置内容_ : IR节点_ {
    IR数字字面量_ 基本大小;
    IR数字字面量_ 数量;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.基本大小 = ··null!(IR数字字面量_);
        this.数量 = ··null!(IR数字字面量_);
    }
}
class 倍数范围设置内容_ : IR节点_ {
    IR数字字面量_ 最小;
    IR数字字面量_ 最大;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.最小 = ··null!(IR数字字面量_);
        this.最大 = ··null!(IR数字字面量_);
    }
}
class 分配大小设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 本地线程设置_ : 多用途设置节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 自定义特性设置_ : 设置型节点_ {
    IR文本字面量_ 键;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.键 = ··null!(IR文本字面量_);
    }
}
class 值表达式_ : IR节点_ {
    IR节点_ 类型;
    IR节点_ 值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.值 = ··null!(IR节点_);
    }
}
class 实参表达式_ : IR节点_ {
    IR节点_ 表达式;
    节点.节点数组_!(IR节点_) 参数特性;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.表达式 = ··null!(IR节点_);
        this.参数特性 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 跳转表元素_ : IR节点_ {
    值表达式_ 条件;
    值表达式_ 标签;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.条件 = ··null!(值表达式_);
        this.标签 = ··null!(值表达式_);
    }
}
class 形参声明_ : 命名声明_ {
    IR节点_ 类型;
    节点.节点数组_!(IR节点_) 形参特性;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.形参特性 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class MDNodeVector_ : IR节点_ {
    节点.节点数组_!(IR节点_) 元素组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class DIExpression_ : IR节点_ {
    节点.节点数组_!(IR节点_) 元素组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class DIArgList_ : IR节点_ {
    节点.节点数组_!(IR节点_) 元素组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.元素组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 元数据键_ : IR节点_ {
    IR节点_ 键;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.键 = ··null!(IR节点_);
    }
}
class 元数据字段_ : 元数据键_ {
    IR节点_ 值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(IR节点_);
    }
}
class 专用元数据字段_ : 元数据键_ {
    节点.节点数组_!(IR节点_) 成员;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.成员 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 数据计算字段_ : 元数据键_ {
    节点.节点数组_!(IR节点_) 运算数组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.运算数组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 函数体_ : IR节点_ {
    节点.节点数组_!(IR节点_) 基本块组;
    用户历史数据_ 用户数据;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.基本块组 = ··null!(节点.节点数组_!(IR节点_));
        this.用户数据 = ··null!(用户历史数据_);
    }
}
class 全局声明_ : 命名声明_ {
    IR节点_ 连接特性;
    IR节点_ 运行时抢占;
    IR节点_ 可见性;
    IR节点_ DLL储存类;
    IR节点_ 未命名的地址;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 全局值声明_ : 全局声明_ {
    IR节点_ 地址空间;
    IR节点_ 段设置;
    IR节点_ 对齐设置;
    IR节点_ 隔板设置;
    IR节点_ 函数封装;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.地址空间 = ··null!(IR节点_);
        this.段设置 = ··null!(IR节点_);
        this.对齐设置 = ··null!(IR节点_);
        this.隔板设置 = ··null!(IR节点_);
        this.函数封装 = ··null!(IR节点_);
    }
}
class 函数基类_ : 全局值声明_ {
    节点.节点数组_!(IR节点_) 参数列表;
    IR节点_ 返回类型;
    IR节点_ 调用约定;
    节点.节点数组_!(IR节点_) 返回类型特性;
    节点.节点数组_!(IR节点_) 函数特性;
    IR节点_ GC设置;
    全局表达式_ 前缀设置;
    全局表达式_ 序言设置;
    全局表达式_ 个性设置;
    bool IsVarArg;
    节点.节点数组_!(IR节点_) 尾部数据;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.参数列表 = ··null!(节点.节点数组_!(IR节点_));
        this.返回类型 = ··null!(IR节点_);
        this.调用约定 = ··null!(IR节点_);
        this.返回类型特性 = ··null!(节点.节点数组_!(IR节点_));
        this.未命名的地址 = ··null!(IR节点_);
        this.函数特性 = ··null!(节点.节点数组_!(IR节点_));
        this.GC设置 = ··null!(IR节点_);
        this.前缀设置 = ··null!(全局表达式_);
        this.序言设置 = ··null!(全局表达式_);
        this.个性设置 = ··null!(全局表达式_);
        this.IsVarArg = false;
        this.尾部数据 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 指令语句_ : IR节点_ {
    节点.节点数组_!(IR节点_) 尾部数据;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.尾部数据 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 设置型语句_ : IR节点_ {
    IR节点_ 值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(IR节点_);
    }
}
class 源码文件名语句_ : 设置型语句_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 目标语句_ : 设置型语句_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 平台设置_ : 设置型节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 封装设置_ : 设置型节点_ {
    bool 有括号;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.有括号 = false;
    }
}
class CC调用约定设置_ : 设置型节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 数据布局设置_ : 设置型节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 模块级汇编_ : 命名声明_ {
    IR节点_ 汇编指令;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.汇编指令 = ··null!(IR节点_);
    }
}
class 函数声明_ : 函数基类_ {
    节点.节点数组_!(IR节点_) 元数据;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.元数据 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 函数定义_ : 函数基类_ {
    函数体_ 函数体;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.函数体 = ··null!(函数体_);
    }
}
class 元数据声明_ : 命名声明_ {
    节点.节点数组_!(IR节点_) 成员组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.成员组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 独立元数据_ : 命名声明_ {
    IR节点_ 新鲜的;
    IR节点_ 元数据;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.新鲜的 = ··null!(IR节点_);
        this.元数据 = ··null!(IR节点_);
    }
}
class 特性声明_ : 命名声明_ {
    节点.节点数组_!(IR节点_) 成员;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.成员 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 局部变量声明_ : 命名声明_ {
    IR节点_ 初始化;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.初始化 = ··null!(IR节点_);
    }
}
class 全局变量声明_ : 全局值声明_ {
    本地线程设置_ 本地线程设置;
    IR节点_ 类型;
    IR节点_ 全局或常量;
    IR节点_ 外部初始化;
    IR节点_ 初始化;
    节点.节点数组_!(IR节点_) 函数特性;
    节点.节点数组_!(IR节点_) 尾部数据;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.全局或常量 = ··null!(IR节点_);
        this.外部初始化 = ··null!(IR节点_);
        this.函数特性 = ··null!(节点.节点数组_!(IR节点_));
        this.初始化 = ··null!(IR节点_);
        this.尾部数据 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 别名声明_ : 全局声明_ {
    IR节点_ 别名令牌;
    本地线程设置_ 本地线程设置;
    IR节点_ 类型;
    IR节点_ 表达式;
    节点.节点数组_!(IR节点_) 隔板组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.别名令牌 = ··null!(IR节点_);
        this.本地线程设置 = ··null!(本地线程设置_);
        this.类型 = ··null!(IR节点_);
        this.表达式 = ··null!(IR节点_);
        this.隔板组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 封装声明_ : 命名声明_ {
    IR节点_ 值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(IR节点_);
    }
}
class 类型声明_ : 命名声明_ {
    IR节点_ 类型;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
    }
}
class 类型引用_ : IR节点_ {
    IR标识符_ 类型名;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型名 = ··null!(IR标识符_);
    }
}
class 整数类型_ : IR节点_ {
    IR数字字面量_ 大小;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.大小 = ··null!(IR数字字面量_);
    }
}
class 结构类型_ : 命名声明_ {
    节点.节点数组_!(IR节点_) 类型组;
    bool 是压缩的;
    bool 是不透明的;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型组 = ··null!(节点.节点数组_!(IR节点_));
        this.是压缩的 = false;
        this.是不透明的 = false;
    }
}
class 数组类型_ : IR节点_ {
    IR节点_ 类型;
    IR数字字面量_ 数量;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.数量 = ··null!(IR数字字面量_);
    }
}
class 向量类型_ : IR节点_ {
    IR节点_ Vector;
    IR节点_ 类型;
    IR数字字面量_ 数量;
    bool 是可扩展的;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.数量 = ··null!(IR数字字面量_);
        this.Vector = ··null!(IR节点_);
        this.是可扩展的 = ··null!(bool);
    }
}
class 指针类型_ : IR节点_ {
    IR节点_ 类型;
    地址空间设置_ 地址空间;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.地址空间 = ··null!(地址空间设置_);
    }
}
class 不透明指针类型_ : IR节点_ {
    IR节点_ 地址空间;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.地址空间 = ··null!(IR节点_);
    }
}
class 函数类型_ : IR节点_ {
    IR节点_ 返回类型;
    节点.节点数组_!(IR节点_) 形参组;
    bool IsVarArg;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.形参组 = ··null!(节点.节点数组_!(IR节点_));
        this.返回类型 = ··null!(IR节点_);
        this.IsVarArg = ··null!(bool);
    }
}
class 用户历史数据_ : 命名声明_ {
    IR节点_ 值;
    节点.节点数组_!(IR节点_) 索引表;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(IR节点_);
        this.索引表 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 用户历史数据_基本块_ : 命名声明_ {
    IR节点_ 函数_;
    IR节点_ 标签;
    节点.节点数组_!(IR节点_) 索引表;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.函数_ = ··null!(IR节点_);
        this.标签 = ··null!(IR节点_);
        this.索引表 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 块声明_ : 命名声明_ {
    节点.节点数组_!(IR节点_) 语句组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.语句组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 不及指令_ : 指令语句_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 返回指令_ : 指令语句_ {
    值表达式_ 表达式;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.表达式 = ··null!(值表达式_);
    }
}
class 跳转指令_ : 指令语句_ {
    值表达式_ 条件; // 提供类型为 标签类型 为直接跳转
    值表达式_ 为真;
    值表达式_ 为假;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.条件 = ··null!(值表达式_);
        this.为真 = ··null!(值表达式_);
        this.为假 = ··null!(值表达式_);
    }
}
class 假如指令_ : 指令语句_ {
    值表达式_ 条件;
    值表达式_ 标签;
    节点.节点数组_!(跳转表元素_) 跳转表;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.条件 = ··null!(值表达式_);
        this.标签 = ··null!(值表达式_);
        this.跳转表 = ··null!(节点.节点数组_!(跳转表元素_));
    }
}
class 直接跳转指令_ : 指令语句_ {
    值表达式_ 值;
    节点.节点数组_!(值表达式_) 跳转表;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(值表达式_);
        this.跳转表 = ··null!(节点.节点数组_!(值表达式_));
    }
}
class 调用基类_ : 指令语句_ {
    IR节点_ name;
    IR节点_ 调用约定;
    节点.节点数组_!(IR节点_) 返回类型特性;
    地址空间设置_ 地址空间;
    IR节点_ 返回类型;
    节点.节点数组_!(IR节点_) 实参列表;
    节点.节点数组_!(IR节点_) 函数特性组;
    操作数标签组_ 捆绑的操作数;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.name = ··null!(IR节点_);
        this.调用约定 = ··null!(IR节点_);
        this.地址空间 = ··null!(地址空间设置_);
        this.返回类型 = ··null!(IR节点_);
        this.实参列表 = ··null!(节点.节点数组_!(IR节点_));
        this.函数特性组 = ··null!(节点.节点数组_!(IR节点_));
        this.捆绑的操作数 = ··null!(操作数标签组_);
        this.返回类型特性 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 唤出指令_ : 调用基类_ {
    值表达式_ 转到块;
    值表达式_ 异常块;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.转到块 = ··null!(值表达式_);
        this.异常块 = ··null!(值表达式_);
    }
}
class 重启指令_ : 指令语句_ {
    值表达式_ 表达式;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.表达式 = ··null!(值表达式_);
    }
}
class 清理返回指令_ : 指令语句_ {
    IR节点_ 起始块; // from  V  unwind to   caller BV
    IR节点_ 目标块; // 标签表达式 | IR令牌_<ISK.caller>;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.起始块 = ··null!(IR节点_);
        this.目标块 = ··null!(IR节点_);
    }
}
class 捕获返回指令_ : 指令语句_ {
    IR节点_ 起始块; // from  V  unwind to   caller BV
    IR节点_ 目标块;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.起始块 = ··null!(IR节点_);
        this.目标块 = ··null!(IR节点_);
    }
}
class 捕获分支指令_ : 指令语句_ {
    IR节点_ 表达式; // from  V  unwind to   caller BV
    节点.节点数组_!(IR节点_) 地址表;
    IR节点_ 展开标签; // 标签表达式 | IR令牌_<ISK.caller>;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.表达式 = ··null!(IR节点_);
        this.地址表 = ··null!(节点.节点数组_!(IR节点_));
        this.展开标签 = ··null!(IR节点_);
    }
}
class 捕获场指令_ : 指令语句_ {
    IR节点_ 表达式; // from  V  unwind to   caller BV
    节点.节点数组_!(IR节点_) 异常参数;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.表达式 = ··null!(IR节点_);
        this.异常参数 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 清理场指令_ : 指令语句_ {
    IR节点_ 表达式; // from  V  unwind to   caller BV
    节点.节点数组_!(IR节点_) 异常参数;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.表达式 = ··null!(IR节点_);
        this.异常参数 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 调用指令_ : 调用基类_ {
    IR节点_ 尾调用修饰符;
    节点.节点数组_!(IR节点_) 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.尾调用修饰符 = ··null!(IR节点_);
        this.快速标志 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 调用跳转指令_ : 调用基类_ {
    节点.节点数组_!(IR节点_) 转到块;
    IR节点_ 默认标签;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.转到块 = ··null!(节点.节点数组_!(IR节点_));
        this.默认标签 = ··null!(IR节点_);
    }
}
class 取反指令_ : 指令语句_ {
    值表达式_ 运算数;
    节点.节点数组_!(IR节点_) 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.运算数 = ··null!(值表达式_);
        this.快速标志 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 二元运算基类_ : 指令语句_ {
    IR节点_ 指令;
    IR节点_ 左值;
    IR节点_ 右值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.指令 = ··null!(IR节点_);
        this.左值 = ··null!(IR节点_);
        this.右值 = ··null!(IR节点_);
    }
}
class 提取值常量表达式_ : IR节点_ {
    IR节点_ Val;
    节点.节点数组_!(IR节点_) Indices;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Val = ··null!(IR节点_);
        this.Indices = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 插入值常量表达式_ : IR节点_ {
    IR节点_ Val0;
    IR节点_ Val1;
    节点.节点数组_!(IR节点_) Indices;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
        this.Indices = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 比较类常量表达式_ : IR节点_ {
    IR节点_ kind;
    IR节点_ PredVal;
    IR节点_ Val0;
    IR节点_ Val1;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.kind = ··null!(IR节点_);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
        this.PredVal = ··null!(IR节点_);
    }
}
class 取反常量表达式_ : IR节点_ {
    IR节点_ Val;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Val = ··null!(IR节点_);
    }
}
class 二元常量表达式_ : IR节点_ {
    IR节点_ op;
    IR节点_ Val0;
    IR节点_ Val1;
    IR节点_ NUW;
    IR节点_ NSW;
    IR节点_ Exact;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.op = ··null!(IR节点_);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
        this.NUW = ··null!(IR节点_);
        this.NSW = ··null!(IR节点_);
        this.Exact = ··null!(IR节点_);
    }
}
class 逻辑类常量表达式_ : IR节点_ {
    IR节点_ op;
    IR节点_ Val0;
    IR节点_ Val1;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.op = ··null!(IR节点_);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
    }
}
class 常量转换类节点_ : IR节点_ {
    IR节点_ op;
    IR节点_ srcVal;
    IR节点_ DestTy;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.op = ··null!(IR节点_);
        this.srcVal = ··null!(IR节点_);
        this.DestTy = ··null!(IR节点_);
    }
}
class DSO局部等效常量表达式_ : IR节点_ {
    IR节点_ 函数_;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.函数_ = ··null!(IR节点_);
    }
}
class 块地址表常量表达式_ : IR节点_ {
    IR节点_ 函数_;
    IR节点_ 标签;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.函数_ = ··null!(IR节点_);
        this.标签 = ··null!(IR节点_);
    }
}
class 获取元素指针常量表达式_ : IR节点_ {
    IR节点_ 在界内;
    IR节点_ 类型;
    节点.节点数组_!(IR节点_) 索引表;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.在界内 = ··null!(IR节点_);
        this.类型 = ··null!(IR节点_);
        this.索引表 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 向量洗牌常量表达式_ : IR节点_ {
    IR节点_ Val0;
    IR节点_ Val1;
    IR节点_ Val2;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
        this.Val2 = ··null!(IR节点_);
    }
}
class 插入元素常量表达式_ : IR节点_ {
    IR节点_ Val0;
    IR节点_ Val1;
    IR节点_ Val2;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
        this.Val2 = ··null!(IR节点_);
    }
}
class 提取元素常量表达式_ : IR节点_ {
    IR节点_ Val0;
    IR节点_ Val1;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
    }
}
class 选择常量表达式_ : IR节点_ {
    IR节点_ Val0;
    IR节点_ Val1;
    IR节点_ Val2;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Val0 = ··null!(IR节点_);
        this.Val1 = ··null!(IR节点_);
        this.Val2 = ··null!(IR节点_);
    }
}
class PHI节点元素_ : IR节点_ {
    IR节点_ 左值;
    IR节点_ 右值;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.左值 = ··null!(IR节点_);
        this.右值 = ··null!(IR节点_);
    }
}
class 捕获或过滤器_ : 指令语句_ {
    IR节点_ 指令;
    值表达式_ 捕获_;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.指令 = ··null!(IR节点_);
        this.捕获_ = ··null!(值表达式_);
    }
}
class 同步范围设置_ : 设置型节点_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 操作数标签_ : 命名声明_ {
    节点.节点数组_!(IR节点_) 标签组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.标签组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 操作数标签组_ : IR节点_ {
    节点.节点数组_!(操作数标签_) 标签组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.标签组 = ··null!(节点.节点数组_!(操作数标签_));
    }
}
class 整数和差积及左移指令_ : 二元运算基类_ {
    节点.节点数组_!(IR节点_) 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.快速标志 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 小数和差积及左移指令_ : 二元运算基类_ {
    节点.节点数组_!(IR节点_) 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.快速标志 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 有无符号求商及右移指令_ : 二元运算基类_ {
    IR节点_ 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.快速标志 = ··null!(IR节点_);
    }
}
class 有无符号求余数运算指令_ : 二元运算基类_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 比较运算指令_ : 二元运算基类_ {
    IR节点_ 副词;
    节点.节点数组_!(IR节点_) 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.副词 = ··null!(IR节点_);
        this.快速标志 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 位运算指令_ : 二元运算基类_ {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
class 转换类指令_ : 指令语句_ {
    IR节点_ 指令;
    值表达式_ 左值;
    IR节点_ 目标类型;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.指令 = ··null!(IR节点_);
        this.左值 = ··null!(值表达式_);
        this.目标类型 = ··null!(IR节点_);
    }
}
class 选择指令_ : 指令语句_ {
    值表达式_ 值0;
    值表达式_ 值1;
    值表达式_ 值2;
    节点.节点数组_!(IR节点_) 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
        this.值2 = ··null!(值表达式_);
        this.快速标志 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 可变参数指令_ : 指令语句_ {
    值表达式_ 值;
    IR节点_ 类型;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(值表达式_);
        this.类型 = ··null!(IR节点_);
    }
}
class 提取元素指令_ : 指令语句_ {
    值表达式_ 值0; // 必须是矢量类型
    值表达式_ 值1; // 必须是矢量元素类型
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
    }
}
class 插入元素指令_ : 指令语句_ {
    值表达式_ 值0; // 必须是矢量类型
    值表达式_ 值1; // 必须是矢量元素类型
    值表达式_ 值2;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
        this.值2 = ··null!(值表达式_);
    }
}
class 洗牌向量指令_ : 指令语句_ {
    值表达式_ 值0; // 必须是矢量类型
    值表达式_ 值1; // 必须是矢量元素类型
    值表达式_ 值2; // 必须是 i32
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
        this.值2 = ··null!(值表达式_);
    }
}
class PHI节点指令_ : 指令语句_ {
    IR节点_ 类型;
    节点.节点数组_!(PHI节点元素_) 节点组;
    节点.节点数组_!(IR节点_) 快速标志;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.节点组 = ··null!(节点.节点数组_!(PHI节点元素_));
        this.标志 = ··null!(ulong);
    }
}
class 着陆场指令_ : 指令语句_ {
    IR节点_ 类型;
    IR节点_ 清理指令;
    节点.节点数组_!(捕获或过滤器_) 捕获或过滤器;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.类型 = ··null!(IR节点_);
        this.清理指令 = ··null!(IR节点_);
        this.捕获或过滤器 = ··null!(节点.节点数组_!(捕获或过滤器_));
    }
}
class 冻结指令_ : 指令语句_ {
    值表达式_ 表达式;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.表达式 = ··null!(值表达式_);
    }
}
class 分配指令_ : 指令语句_ {
    IR节点_ IsInAlloca;
    IR节点_ IsSwiftError;
    IR节点_ 类型; // 不能是函数类型
    IR节点_ Alignment;
    IR节点_ AddrSpace;
    IR节点_ Size;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.IsInAlloca = ··null!(IR节点_);
        this.IsSwiftError = ··null!(IR节点_);
        this.类型 = ··null!(IR节点_);
        this.Alignment = ··null!(IR节点_);
        this.AddrSpace = ··null!(IR节点_);
        this.Size = ··null!(IR节点_);
    }
}
class 加载指令_ : 指令语句_ {
    IR节点_ isAtomic;
    IR节点_ isVolatile;
    IR节点_ Alignment;
    IR节点_ 类型; // 不能是函数类型
    值表达式_ 表达式;
    同步范围设置_ 同步;
    IR节点_ 排序;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.isAtomic = ··null!(IR节点_);
        this.isVolatile = ··null!(IR节点_);
        this.Alignment = ··null!(IR节点_);
        this.类型 = ··null!(IR节点_);
        this.表达式 = ··null!(值表达式_);
        this.同步 = ··null!(同步范围设置_);
        this.排序 = ··null!(IR节点_);
    }
}
class 储存指令_ : 指令语句_ {
    IR节点_ isAtomic;
    IR节点_ isVolatile;
    IR节点_ Alignment;
    值表达式_ 值0; // 不能是函数类型
    值表达式_ 值1;
    同步范围设置_ 同步;
    IR节点_ 排序;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.isAtomic = ··null!(IR节点_);
        this.isVolatile = ··null!(IR节点_);
        this.Alignment = ··null!(IR节点_);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
        this.同步 = ··null!(同步范围设置_);
        this.排序 = ··null!(IR节点_);
    }
}
class 原子修改内存按条件指令_ : 指令语句_ {
    IR节点_ isWeak;
    IR节点_ isVolatile;
    IR节点_ Alignment;
    值表达式_ 值0;
    值表达式_ 值1;
    值表达式_ 值2;
    IR节点_ 真排序;
    IR节点_ 假排序;
    同步范围设置_ 同步;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.isWeak = ··null!(IR节点_);
        this.isVolatile = ··null!(IR节点_);
        this.Alignment = ··null!(IR节点_);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
        this.值2 = ··null!(值表达式_);
        this.真排序 = ··null!(IR节点_);
        this.假排序 = ··null!(IR节点_);
        this.同步 = ··null!(同步范围设置_);
    }
}
class 原子修改内存指令_ : 指令语句_ {
    IR节点_ isVolatile;
    IR节点_ Alignment;
    IR节点_ 运算;
    值表达式_ 值0;
    值表达式_ 值1;
    同步范围设置_ 同步;
    IR节点_ 排序;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.isVolatile = ··null!(IR节点_);
        this.Alignment = ··null!(IR节点_);
        this.运算 = ··null!(IR节点_);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
        this.同步 = ··null!(同步范围设置_);
        this.排序 = ··null!(IR节点_);
    }
}
class 栅格指令_ : 指令语句_ {
    IR节点_ 排序;
    同步范围设置_ 同步;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.同步 = ··null!(同步范围设置_);
        this.排序 = ··null!(IR节点_);
    }
}
class 获取元素指针指令_ : 指令语句_ {
    IR节点_ 在界内;
    IR节点_ 类型;
    值表达式_ 值0;
    节点.节点数组_!(值表达式_) 索引组; // 检查之后初始化
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.在界内 = ··null!(IR节点_);
        this.类型 = ··null!(IR节点_);
        this.值0 = ··null!(值表达式_);
        this.索引组 = ··null!(节点.节点数组_!(值表达式_));
    }
}
class 提取值指令_ : 指令语句_ {
    值表达式_ 值;
    节点.节点数组_!(IR节点_) 索引表;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值 = ··null!(值表达式_);
        this.索引表 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 插入值指令_ : 指令语句_ {
    值表达式_ 值0;
    值表达式_ 值1;
    节点.节点数组_!(IR节点_) 索引表;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.值0 = ··null!(值表达式_);
        this.值1 = ··null!(值表达式_);
        this.索引表 = ··null!(节点.节点数组_!(IR节点_));
    }
}
// 摘要
class 全局摘要声明_ : 命名声明_ {
    IR节点_ 初始化; //全局值摘要 | 模块摘要 | 类型id摘要 | 类型id兼容表摘要 | 标志摘要值组设置 | 块数摘要设置;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.初始化 = ··null!(IR节点_);
    }
}
class 全局值摘要_ : IR节点_ {
    IR节点_ name;
    IR数字字面量_ GUID;
    摘要多值设置_ 摘要组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.name = ··null!(IR节点_);
        this.GUID = ··null!(IR数字字面量_);
        this.摘要组 = ··null!(摘要多值设置_);
    }
}
class 摘要多值设置_ : 设置型节点_ {
    IR节点_ 键;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.键 = ··null!(IR节点_);
    }
}
class 摘要值设置_ : 设置型节点_ {
    IR节点_ 键;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.键 = ··null!(IR节点_);
    }
}
class 全局值引用摘要_ : IR节点_ {
    IR节点_ GVID;
    IR节点_ 只读或只写;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.GVID = ··null!(IR节点_);
        this.只读或只写 = ··null!(IR节点_);
    }
}
class 被调用者摘要_ : IR节点_ {
    IR节点_ 全局引用;
    IR节点_ 热度或频率设置;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.全局引用 = ··null!(IR节点_);
        this.热度或频率设置 = ··null!(IR节点_);
    }
}
class 虚函数id摘要_ : IR节点_ {
    IR节点_ ID;
    IR节点_ GUID;
    IR节点_ 偏移;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.ID = ··null!(IR节点_);
        this.GUID = ··null!(IR节点_);
        this.偏移 = ··null!(IR节点_);
    }
}
class 常量虚调用摘要_ : IR节点_ {
    IR节点_ ID;
    IR节点_ 实参摘要;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.ID = ··null!(IR节点_);
        this.实参摘要 = ··null!(IR节点_);
    }
}
class 虚函数摘要_ : IR节点_ {
    IR节点_ ID;
    IR节点_ 偏移;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.ID = ··null!(IR节点_);
        this.偏移 = ··null!(IR节点_);
    }
}
class 别名摘要_ : IR节点_ {
    IR节点_ ModulePath;
    IR节点_ GVFlags;
    IR节点_ AliaseeVI;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.ModulePath = ··null!(IR节点_);
        this.GVFlags = ··null!(IR节点_);
        this.AliaseeVI = ··null!(IR节点_);
    }
}
class 形参偏移摘要_ : IR节点_ {
    IR数字字面量_ Lower;
    IR数字字面量_ Upper;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Lower = ··null!(IR数字字面量_);
        this.Upper = ··null!(IR数字字面量_);
    }
}
class 形参访问调用摘要_ : IR节点_ {
    IR节点_ GVR;
    IR节点_ ParamNo;
    IR节点_ Offsets;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.GVR = ··null!(IR节点_);
        this.Offsets = ··null!(IR节点_);
    }
}
class 形参访问摘要_ : IR节点_ {
    IR节点_ ParamNo;
    IR节点_ Offsets;
    IR节点_ calls;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.ParamNo = ··null!(IR节点_);
        this.Offsets = ··null!(IR节点_);
        this.calls = ··null!(IR节点_);
    }
}
class 函数摘要_ : IR节点_ {
    IR节点_ 模块引用;
    IR节点_ 全局标志;
    IR节点_ 学院设置;
    节点.节点数组_!(IR节点_) 信息组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.模块引用 = ··null!(IR节点_);
        this.全局标志 = ··null!(IR节点_);
        this.学院设置 = ··null!(IR节点_);
        this.信息组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 变量摘要_ : IR节点_ {
    IR节点_ 模块引用;
    IR节点_ GVFlags;
    IR节点_ GVarFlags;
    节点.节点数组_!(IR节点_) 信息组;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.模块引用 = ··null!(IR节点_);
        this.GVFlags = ··null!(IR节点_);
        this.GVarFlags = ··null!(IR节点_);
        this.信息组 = ··null!(节点.节点数组_!(IR节点_));
    }
}
class 模块摘要_ : IR节点_ {
    IR节点_ 路径;
    IR节点_ 哈希;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.路径 = ··null!(IR节点_);
        this.哈希 = ··null!(IR节点_);
    }
}
class 偏移及引用_ : IR节点_ {
    IR节点_ 偏移;
    IR节点_ 驱动;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.偏移 = ··null!(IR节点_);
        this.驱动 = ··null!(IR节点_);
    }
}
class 类型id内容摘要_ : IR节点_ {
    IR节点_ Name;
    IR节点_ TIS;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Name = ··null!(IR节点_);
        this.TIS = ··null!(IR节点_);
    }
}
class 类型id兼容表摘要_ : IR节点_ {
    IR节点_ Name;
    IR节点_ summary;
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
        this.Name = ··null!(IR节点_);
        this.summary = ··null!(IR节点_);
    }
}
class 空语句_ : IR令牌_!(ISK) {
    this() { }
    this(ISK isk, long 开始 = -1, long 结束 = -1) {
        super(isk, 开始, 结束);
    }
}
IR源文件_ 创建源文件() {
    return new IR源文件_(ISK.源文件);
}
T 创建节点(T)(ISK isk, long 开始 = -1, long 结束 = -1) {
    return new T(isk, 开始, 结束);
}
bool 是IR节点(节点.节点_ n) {
    return n.目标 == TK.Ir && n.种类 != SK.源文件;
}
IR节点_ 获取IR节点(节点.节点_ n) {
    if (.是IR节点(n)) {
        return (cast(IR节点_)(n));
    }
    return ··null!(IR节点_);
}
bool 是局部声明语句(IR节点_ nn) {
    switch (nn.目标种类) {
        case ISK.分配指令:
        case ISK.加载指令:
        case ISK.原子修改内存按条件指令:
        case ISK.原子修改内存指令:
        case ISK.获取元素指针指令:
        case ISK.提取值指令:
        case ISK.插入值指令:
        case ISK.整数和差积及左移指令:
        case ISK.小数和差积及左移指令:
        case ISK.有无符号求商及右移指令:
        case ISK.有无符号求余数运算指令:
        case ISK.位运算指令:
        case ISK.比较运算指令:
        case ISK.转换类指令:
        case ISK.选择指令:
        case ISK.可变参数指令:
        case ISK.提取元素指令:
        case ISK.插入元素指令:
        case ISK.洗牌向量指令:
        case ISK.PHI节点指令:
        case ISK.着陆场指令:
        case ISK.冻结指令:
        case ISK.取反指令:
        case ISK.清理场指令: // token 类型
        case ISK.捕获场指令: // token 类型
        case ISK.捕获分支指令: {
            return true;
        }
        case ISK.调用跳转指令:
        case ISK.唤出指令:
        case ISK.调用指令: {
            调用基类_ n = (cast(调用基类_)(nn));
            if (n.返回类型.目标种类 == ISK.函数类型) {
                IR节点_ retT = (cast(函数类型_)(n.返回类型)).返回类型;
                return retT.目标种类 != ISK.void_;
            }
            return n.返回类型.目标种类 != ISK.void_;
        }
        default: break;
    }
    return false;
}
bool 遍历节点(节点.节点_ node, bool delegate(节点.节点_) cbNode, bool delegate(节点.节点数组_!(节点.节点_)) cbNodes = ··null!(bool delegate(节点.节点数组_!(节点.节点_)))) {
    if ((node is ··null!(节点.节点_)) || node.种类 <= SK.标识符) {
        return false;
    }
    if (node.种类 == SK.源文件) {
        IR源文件_ sou = (cast(IR源文件_)((cast(节点.源文件_)(node))));
        return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), sou.语句组) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), sou.文件结尾令牌);
    }
    IR节点_ ir节点 = .获取IR节点(node);
    if (ir节点 is ··null!(IR节点_)) {
        return false;
    }
    long k = ir节点.目标种类;
    switch (k) {
        case ISK.目标语句: {
            目标语句_ n = (cast(目标语句_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.封装设置: {
            封装设置_ n = (cast(封装设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.平台设置: {
            平台设置_ n = (cast(平台设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.数据布局设置: {
            数据布局设置_ n = (cast(数据布局设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.源码文件名语句: {
            源码文件名语句_ n = (cast(源码文件名语句_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.CC调用约定设置: {
            CC调用约定设置_ n = (cast(CC调用约定设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.自定义特性设置: {
            自定义特性设置_ n = (cast(自定义特性设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.不可引用的设置: {
            不可引用的设置_ n = (cast(不可引用的设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.不可引用的或空设置: {
            不可引用的或空设置_ n = (cast(不可引用的或空设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.对齐设置: {
            对齐设置_ n = (cast(对齐设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.类型引用: {
            类型引用_ n = (cast(类型引用_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型名);
        }
        case ISK.结构类型: {
            结构类型_ n = (cast(结构类型_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.类型组));
        }
        case ISK.向量类型: {
            向量类型_ n = (cast(向量类型_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Vector) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.数量) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case ISK.数组类型: {
            数组类型_ n = (cast(数组类型_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.数量) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case ISK.地址空间设置: {
            地址空间设置_ n = (cast(地址空间设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.指针类型: {
            指针类型_ n = (cast(指针类型_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.地址空间);
        }
        case ISK.对齐堆栈设置: {
            对齐堆栈设置_ n = (cast(对齐堆栈设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.分配大小设置: {
            分配大小设置_ n = (cast(分配大小设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.分配大小设置内容: {
            分配大小设置内容_ n = (cast(分配大小设置内容_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.基本大小) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.数量);
        }
        case ISK.倍数范围设置: {
            倍数范围设置_ n = (cast(倍数范围设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.倍数范围设置内容: {
            倍数范围设置内容_ n = (cast(倍数范围设置内容_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.最大) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.最小);
        }
        case ISK.形参声明: {
            形参声明_ n = (cast(形参声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name);
        }
        case ISK.函数类型: {
            函数类型_ n = (cast(函数类型_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.返回类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.形参组));
        }
        case ISK.全局表达式: {
            全局表达式_ n = (cast(全局表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.InRangeOp);
        }
        case ISK.结构常量表达式: {
            结构常量表达式_ n = (cast(结构常量表达式_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case ISK.向量常量表达式: {
            向量常量表达式_ n = (cast(向量常量表达式_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case ISK.数组常量表达式: {
            数组常量表达式_ n = (cast(数组常量表达式_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case ISK.c文本常量: {
            c文本常量_ n = (cast(c文本常量_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.内容);
        }
        case ISK.内联汇编常量表达式: {
            内联汇编常量表达式_ n = (cast(内联汇编常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.HasSideEffect) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.AlignStack) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.AsmDialect) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.CanThrow) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.StrVal) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.StrVal2);
        }
        case ISK.块地址表常量表达式: {
            块地址表常量表达式_ n = (cast(块地址表常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数_) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标签);
        }
        case ISK.DSO局部等效常量表达式: {
            DSO局部等效常量表达式_ n = (cast(DSO局部等效常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数_);
        }
        case ISK.常量转换类节点: {
            常量转换类节点_ n = (cast(常量转换类节点_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.op) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.srcVal) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.DestTy);
        }
        case ISK.提取值常量表达式: {
            提取值常量表达式_ n = (cast(提取值常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.Indices));
        }
        case ISK.插入值常量表达式: {
            插入值常量表达式_ n = (cast(插入值常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.Indices));
        }
        case ISK.比较类常量表达式: {
            比较类常量表达式_ n = (cast(比较类常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.kind) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.PredVal) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1);
        }
        case ISK.取反常量表达式: {
            取反常量表达式_ n = (cast(取反常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val);
        }
        case ISK.二元常量表达式: {
            二元常量表达式_ n = (cast(二元常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.op) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.NUW) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.NSW) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Exact);
        }
        case ISK.逻辑类常量表达式: {
            逻辑类常量表达式_ n = (cast(逻辑类常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.op) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1);
        }
        case ISK.获取元素指针常量表达式: {
            获取元素指针常量表达式_ n = (cast(获取元素指针常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.在界内) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.索引表));
        }
        case ISK.向量洗牌常量表达式: {
            向量洗牌常量表达式_ n = (cast(向量洗牌常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val2);
        }
        case ISK.插入元素常量表达式: {
            插入元素常量表达式_ n = (cast(插入元素常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val2);
        }
        case ISK.提取元素常量表达式: {
            提取元素常量表达式_ n = (cast(提取元素常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1);
        }
        case ISK.选择常量表达式: {
            选择常量表达式_ n = (cast(选择常量表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Val2);
        }
        case ISK.MDNodeVector: {
            MDNodeVector_ n = (cast(MDNodeVector_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case ISK.DIExpression: {
            DIExpression_ n = (cast(DIExpression_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case ISK.DIArgList: {
            DIArgList_ n = (cast(DIArgList_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元素组));
        }
        case ISK.专用元数据字段: {
            专用元数据字段_ n = (cast(专用元数据字段_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员));
        }
        case ISK.元数据字段: {
            元数据字段_ n = (cast(元数据字段_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.数据计算字段: {
            数据计算字段_ n = (cast(数据计算字段_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.运算数组));
        }
        case ISK.返回指令: {
            返回指令_ n = (cast(返回指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.值表达式: {
            值表达式_ n = (cast(值表达式_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.跳转指令: {
            跳转指令_ n = (cast(跳转指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.条件) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.为真) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.为假) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.跳转表元素: {
            跳转表元素_ n = (cast(跳转表元素_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.条件) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标签);
        }
        case ISK.假如指令: {
            假如指令_ n = (cast(假如指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.条件) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标签) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.跳转表)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.直接跳转指令: {
            直接跳转指令_ n = (cast(直接跳转指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.跳转表)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.操作数标签: {
            操作数标签_ n = (cast(操作数标签_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.标签组));
        }
        case ISK.操作数标签组: {
            操作数标签组_ n = (cast(操作数标签组_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.标签组));
        }
        case ISK.实参表达式: {
            实参表达式_ n = (cast(实参表达式_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.参数特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式);
        }
        case ISK.唤出指令: {
            唤出指令_ n = (cast(唤出指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.调用约定) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.返回类型特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.地址空间) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.返回类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.实参列表)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.函数特性组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.捆绑的操作数) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.转到块) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.异常块) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.重启指令: {
            重启指令_ n = (cast(重启指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.清理返回指令: {
            清理返回指令_ n = (cast(清理返回指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.起始块) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.目标块) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.捕获返回指令: {
            捕获返回指令_ n = (cast(捕获返回指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.起始块) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.目标块) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.捕获分支指令: {
            捕获分支指令_ n = (cast(捕获分支指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.地址表)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.展开标签) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.捕获场指令: {
            捕获场指令_ n = (cast(捕获场指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.异常参数)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.清理场指令: {
            清理场指令_ n = (cast(清理场指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.异常参数)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.调用跳转指令: {
            调用跳转指令_ n = (cast(调用跳转指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.调用约定) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.返回类型特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.地址空间) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.返回类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.实参列表)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.函数特性组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.捆绑的操作数) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.默认标签) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.转到块)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.取反指令: {
            取反指令_ n = (cast(取反指令_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.快速标志)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.运算数) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.整数和差积及左移指令: {
            整数和差积及左移指令_ n = (cast(整数和差积及左移指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.快速标志)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.小数和差积及左移指令: {
            小数和差积及左移指令_ n = (cast(小数和差积及左移指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.快速标志)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.有无符号求商及右移指令: {
            有无符号求商及右移指令_ n = (cast(有无符号求商及右移指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.快速标志) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.有无符号求余数运算指令: {
            有无符号求余数运算指令_ n = (cast(有无符号求余数运算指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.位运算指令: {
            位运算指令_ n = (cast(位运算指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.比较运算指令: {
            比较运算指令_ n = (cast(比较运算指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.副词) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.快速标志)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.选择指令: {
            选择指令_ n = (cast(选择指令_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.快速标志)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值2) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.转换类指令: {
            转换类指令_ n = (cast(转换类指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.目标类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.可变参数指令: {
            可变参数指令_ n = (cast(可变参数指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.提取元素指令: {
            提取元素指令_ n = (cast(提取元素指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.插入元素指令: {
            插入元素指令_ n = (cast(插入元素指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值2) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.洗牌向量指令: {
            洗牌向量指令_ n = (cast(洗牌向量指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值2) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.PHI节点元素: {
            PHI节点元素_ n = (cast(PHI节点元素_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.左值) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.右值);
        }
        case ISK.PHI节点指令: {
            PHI节点指令_ n = (cast(PHI节点指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.快速标志)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.节点组)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.捕获或过滤器: {
            捕获或过滤器_ n = (cast(捕获或过滤器_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.指令) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.捕获_);
        }
        case ISK.着陆场指令: {
            着陆场指令_ n = (cast(着陆场指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.清理指令) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.捕获或过滤器)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.冻结指令: {
            冻结指令_ n = (cast(冻结指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.调用指令: {
            调用指令_ n = (cast(调用指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.尾调用修饰符) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.快速标志)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.调用约定) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.返回类型特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.地址空间) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.返回类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.实参列表)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.函数特性组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.捆绑的操作数) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.分配指令: {
            分配指令_ n = (cast(分配指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.IsInAlloca) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.IsSwiftError) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Alignment) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.AddrSpace) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Size) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.同步范围设置: {
            同步范围设置_ n = (cast(同步范围设置_)(ir节点));
        }
        case ISK.加载指令: {
            加载指令_ n = (cast(加载指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.isAtomic) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.isVolatile) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.同步) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.排序) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Alignment) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.储存指令: {
            储存指令_ n = (cast(储存指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.isAtomic) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.isVolatile) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.同步) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.排序) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Alignment) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.原子修改内存按条件指令: {
            原子修改内存按条件指令_ n = (cast(原子修改内存按条件指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.isWeak) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.isVolatile) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值2) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.同步) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.真排序) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.假排序) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Alignment) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.原子修改内存指令: {
            原子修改内存指令_ n = (cast(原子修改内存指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.isVolatile) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.运算) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.同步) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.排序) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Alignment) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.栅格指令: {
            栅格指令_ n = (cast(栅格指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.同步) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.排序) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.获取元素指针指令: {
            获取元素指针指令_ n = (cast(获取元素指针指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.在界内) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.索引组)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.提取值指令: {
            提取值指令_ n = (cast(提取值指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.索引表)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.插入值指令: {
            插入值指令_ n = (cast(插入值指令_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值0) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值1) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.索引表)) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.用户历史数据: {
            用户历史数据_ n = (cast(用户历史数据_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.索引表));
        }
        case ISK.局部变量声明: {
            局部变量声明_ n = (cast(局部变量声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case ISK.块声明: {
            块声明_ n = (cast(块声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.语句组));
        }
        case ISK.按引用设置: {
            按引用设置_ n = (cast(按引用设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.按值设置: {
            按值设置_ n = (cast(按值设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.结构引用设置: {
            结构引用设置_ n = (cast(结构引用设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.预分配设置: {
            预分配设置_ n = (cast(预分配设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.在内部分配设置: {
            在内部分配设置_ n = (cast(在内部分配设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.不及指令: {
            不及指令_ n = (cast(不及指令_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.整数类型: {
            整数类型_ n = (cast(整数类型_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.大小);
        }
        case ISK.类型声明: {
            类型声明_ n = (cast(类型声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型);
        }
        case ISK.封装声明: {
            封装声明_ n = (cast(封装声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.特性声明: {
            特性声明_ n = (cast(特性声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员));
        }
        case ISK.元数据声明: {
            元数据声明_ n = (cast(元数据声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.成员组));
        }
        case ISK.本地线程设置: {
            本地线程设置_ n = (cast(本地线程设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.用户历史数据_基本块: {
            用户历史数据_基本块_ n = (cast(用户历史数据_基本块_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数_) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.标签) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.索引表));
        }
        case ISK.函数声明: {
            函数声明_ n = (cast(函数声明_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.元数据)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.连接特性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.运行时抢占) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.可见性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.DLL储存类) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.调用约定) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.返回类型特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.返回类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.参数列表)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.未命名的地址) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.地址空间) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.函数特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.段设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.隔板设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数封装) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.对齐设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GC设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.前缀设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.序言设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.个性设置);
        }
        case ISK.函数定义: {
            函数定义_ n = (cast(函数定义_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.连接特性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.运行时抢占) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.可见性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.DLL储存类) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.调用约定) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.返回类型特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.返回类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.参数列表)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.未命名的地址) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.地址空间) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.函数特性)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.段设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.隔板设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数封装) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.对齐设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GC设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.前缀设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.序言设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.个性设置) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数体);
        }
        case ISK.函数体: {
            函数体_ n = (cast(函数体_)(ir节点));
            return 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.基本块组)) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.用户数据);
        }
        case ISK.全局变量声明: {
            全局变量声明_ n = (cast(全局变量声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.连接特性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.运行时抢占) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.可见性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.DLL储存类) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.本地线程设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.未命名的地址) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.地址空间) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.外部初始化) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.全局或常量) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.段设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.对齐设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.隔板设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.函数封装) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.尾部数据));
        }
        case ISK.别名声明: {
            别名声明_ n = (cast(别名声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.连接特性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.运行时抢占) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.可见性) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.DLL储存类) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.本地线程设置) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.未命名的地址) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.别名令牌) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.类型) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.表达式) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.隔板组));
        }
        case ISK.模块级汇编: {
            模块级汇编_ n = (cast(模块级汇编_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.汇编指令);
        }
        case ISK.独立元数据: {
            独立元数据_ n = (cast(独立元数据_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.新鲜的) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.元数据);
        }
        case ISK.全局摘要声明: {
            全局摘要声明_ n = (cast(全局摘要声明_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.初始化);
        }
        case ISK.全局值摘要: {
            全局值摘要_ n = (cast(全局值摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GUID) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.摘要组);
        }
        case ISK.摘要多值设置: {
            摘要多值设置_ n = (cast(摘要多值设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.值组));
        }
        case ISK.函数摘要: {
            函数摘要_ n = (cast(函数摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.模块引用) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.全局标志) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.学院设置) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.信息组));
        }
        case ISK.摘要值设置: {
            摘要值设置_ n = (cast(摘要值设置_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.键) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.值);
        }
        case ISK.全局值引用摘要: {
            全局值引用摘要_ n = (cast(全局值引用摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.只读或只写) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GVID);
        }
        case ISK.被调用者摘要: {
            被调用者摘要_ n = (cast(被调用者摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.全局引用) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.热度或频率设置);
        }
        case ISK.虚函数id摘要: {
            虚函数id摘要_ n = (cast(虚函数id摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.ID) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GUID) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.偏移);
        }
        case ISK.常量虚调用摘要: {
            常量虚调用摘要_ n = (cast(常量虚调用摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.ID) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.实参摘要);
        }
        case ISK.虚函数摘要: {
            虚函数摘要_ n = (cast(虚函数摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.ID) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.偏移);
        }
        case ISK.别名摘要: {
            别名摘要_ n = (cast(别名摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.ModulePath) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GVFlags) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.AliaseeVI);
        }
        case ISK.形参偏移摘要: {
            形参偏移摘要_ n = (cast(形参偏移摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Lower) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Upper);
        }
        case ISK.形参访问调用摘要: {
            形参访问调用摘要_ n = (cast(形参访问调用摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GVR) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.ParamNo) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Offsets);
        }
        case ISK.形参访问摘要: {
            形参访问摘要_ n = (cast(形参访问摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.ParamNo) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Offsets) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.calls);
        }
        case ISK.变量摘要: {
            变量摘要_ n = (cast(变量摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.模块引用) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GVFlags) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.GVarFlags) || 访问节点组(cast(bool delegate(节点.节点_))(cbNode), cast(bool delegate(节点.节点数组_!(节点.节点_)))(cbNodes), ·to!(节点.节点数组_!(节点.节点_))(n.信息组));
        }
        case ISK.模块摘要: {
            模块摘要_ n = (cast(模块摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.路径) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.哈希);
        }
        case ISK.偏移及引用: {
            偏移及引用_ n = (cast(偏移及引用_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.偏移) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.驱动);
        }
        case ISK.类型id内容摘要: {
            类型id内容摘要_ n = (cast(类型id内容摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.TIS);
        }
        case ISK.类型id兼容表摘要: {
            类型id兼容表摘要_ n = (cast(类型id兼容表摘要_)(ir节点));
            return 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.Name) || 访问节点(cast(bool delegate(节点.节点_))(cbNode), n.summary);
        }
        default: break;
    }
    return false;
}
